Impact analysis is an important step in the software development cycle. Impact analysis is done to identify software artifacts such as requirement, design, class and test artifacts that are potentially affected by a change. Such a change may be in the form of addition, removal or modification of the software artifacts. The change impact analysis helps identify potential consequences of the change or estimating what needs to be modified to accomplish the change. The impact analysis identifies the test cases that should be re-executed to ensure that the change was implemented correctly.
The code change in one function point may have deterministic impact on a different function point; it may be evaluated through function point call stack dependencies. Existing tools use a static code analysis and a dynamic code analysis to identify the changes. But there are situations where the change in the one function point may impact a disconnected function point, due to dynamic calls or due to usage of the same runtime entities. The impact analysis using the static code analysis or the runtime stack analysis may not be sufficient in such situations. However, the static code and the dynamic code analysis restrict identification of the impacted changes based on analysis of syntax and/or call graphs. The test cases are primarily developed to ensure that the core functional components are always within the defined specifications, in order to identify the impacts to the test cases; there is a need for an improved method compared to the existing static code analysis or the call graph analysis.
The impact analysis becomes more difficult to the software developer, if the size of the applications or the functional components are huge, if the applications or the components change from one organization to another, and if there is a lot turnover in the developers responsible for the management of the applications or the components.
As the applications and/or the functional components age and the developers change, there is a possibility that the test cases may go out-of-sync with the functionality; then the knowledge to derive impacts may be lost. Hence, there is a need for the software developers to identify the set of artifacts that belongs to the category of unit test cases, integration tests, build scripts etc., impacted by the code changes in the functional components and/or the applications. Therefore, there is a need to predict impacted test cases that need to be changed whenever there is a change in the functional components of the computer application.